home *** CD-ROM | disk | FTP | other *** search
/ CD Exchange / CD Exchange - Volume 1.iso / games / pd / chess / src.lha / src / dspcom.c < prev    next >
C/C++ Source or Header  |  1992-09-07  |  30KB  |  1,324 lines
  1. /*
  2.  * dspcom.c - C source for GNU CHESS
  3.  *
  4.  * Copyright (c) 1988,1989,1990 John Stanback
  5.  * Copyright (c) 1992 Free Software Foundation
  6.  *
  7.  * This file is part of GNU CHESS.
  8.  *
  9.  * GNU Chess is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2, or (at your option)
  12.  * any later version.
  13.  *
  14.  * GNU Chess is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with GNU Chess; see the file COPYING.  If not, write to
  21.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  */
  23. #include "gnuchess.h"
  24. #include "ataks.h"
  25. extern short Mwpawn[64], Mbpawn[64], Mknight[2][64], Mbishop[2][64];
  26. extern char *version, *patchlevel;
  27. char mvstr[4][6];
  28. char *InPtr;
  29.  
  30.  
  31. #include <ctype.h>
  32. #include <signal.h>
  33. #ifdef MSDOS
  34. #include <dos.h>
  35. #include <conio.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38. #include <time.h>
  39. #else
  40. #ifndef AMIGA
  41. #include <sys/param.h>
  42. #include <sys/types.h>
  43. #include <sys/file.h>
  44. #include <sys/ioctl.h>
  45. #define WarnMessage ShowMessage
  46. #else
  47. #include <sys/types.h>
  48. extern int get_command;
  49. #endif /* AMIGA */
  50. #endif /* MSDOS */
  51.  
  52. void
  53. algbr (short int f, short int t, short int flag)
  54.  
  55.  
  56. /*
  57.  * Generate move strings in different formats.
  58.  */
  59.  
  60. {
  61.   int m3p;
  62.  
  63.   if (f != t)
  64.     {
  65.       /* algebraic notation */
  66.       mvstr[0][0] = cxx[column (f)];
  67.       mvstr[0][1] = rxx[row (f)];
  68.       mvstr[0][2] = cxx[column (t)];
  69.       mvstr[0][3] = rxx[row (t)];
  70.       mvstr[0][4] = mvstr[3][0] = '\0';
  71.       if (((mvstr[1][0] = pxx[board[f]]) == 'P') || (flag & promote))
  72.     {
  73.       if (mvstr[0][0] == mvstr[0][2])    /* pawn did not eat */
  74.         {
  75.           mvstr[2][0] = mvstr[1][0] = mvstr[0][2];    /* to column */
  76.           mvstr[2][1] = mvstr[1][1] = mvstr[0][3];    /* to row */
  77.           m3p = 2;
  78.         }
  79.       else
  80.         /* pawn ate */
  81.         {
  82.           mvstr[2][0] = mvstr[1][0] = mvstr[0][0];    /* column */
  83.           mvstr[2][1] = mvstr[1][1] = mvstr[0][2];    /* to column */
  84.           mvstr[2][2] = mvstr[0][3];
  85.           m3p = 3;        /* to row */
  86.         }
  87.       if (flag & promote)
  88.         {
  89.           mvstr[0][4] = mvstr[1][2] = mvstr[2][m3p] = qxx[flag & pmask];
  90.           mvstr[0][5] = mvstr[1][3] = mvstr[2][m3p + 1] = mvstr[3][0] = '\0';
  91. #ifdef CHESSTOOL
  92.           mvstr[3][0] = mvstr[0][0];    /* Allow e7e8 for chesstool */
  93.           mvstr[3][1] = mvstr[0][1];
  94.           mvstr[3][2] = mvstr[0][2];
  95.           mvstr[3][3] = mvstr[0][3];
  96.           mvstr[3][4] = '\0';
  97. #endif
  98.         }
  99.       mvstr[2][m3p] = mvstr[1][2] = '\0';
  100.     }
  101.       else
  102.     /* not a pawn */
  103.     {
  104.       mvstr[2][0] = mvstr[1][0];
  105.       mvstr[2][1] = mvstr[0][1];
  106.       mvstr[2][2] = mvstr[1][1] = mvstr[0][2];    /* to column */
  107.       mvstr[2][3] = mvstr[1][2] = mvstr[0][3];    /* to row */
  108.       mvstr[2][4] = mvstr[1][3] = '\0';
  109.       strcpy (mvstr[3], mvstr[2]);
  110.       mvstr[3][1] = mvstr[0][0];
  111.       if (flag & cstlmask)
  112.         {
  113.           if (t > f)
  114.         {
  115.           strcpy (mvstr[1], CP[5]);
  116.           strcpy (mvstr[2], CP[7]);
  117.         }
  118.           else
  119.         {
  120.           strcpy (mvstr[1], CP[6]);
  121.           strcpy (mvstr[2], CP[8]);
  122.         }
  123.         }
  124.     }
  125.     }
  126.   else
  127.     mvstr[0][0] = mvstr[1][0] = mvstr[2][0] = mvstr[3][0] = '\0';
  128. }
  129.  
  130.  
  131. int
  132. VerifyMove (char *s, short int iop,  unsigned short int *mv)
  133.  
  134. /*
  135.  * Compare the string 's' to the list of legal moves available for the
  136.  * opponent. If a match is found, make the move on the board.
  137.  */
  138.  
  139. {
  140.   static short pnt, tempb, tempc, tempsf, tempst, cnt;
  141.   static struct leaf xnode;
  142.   struct leaf *node;
  143.  
  144.   *mv = 0;
  145.   if (iop == 2)
  146.     {
  147.       UnmakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst);
  148.       return (false);
  149.     }
  150.   cnt = 0;
  151.   MoveList (opponent, 2);
  152.   pnt = TrPnt[2];
  153.   while (pnt < TrPnt[3])
  154.     {
  155.       node = &Tree[pnt++];
  156.       algbr (node->f, node->t, (short) node->flags);
  157.       if (strcmp (s, mvstr[0]) == 0 || strcmp (s, mvstr[1]) == 0 ||
  158.       strcmp (s, mvstr[2]) == 0 || strcmp (s, mvstr[3]) == 0)
  159.     {
  160.       cnt++;
  161.       xnode = *node;
  162.     }
  163.     }
  164.   if (cnt == 1)
  165.     {
  166.       MakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst, &INCscore);
  167.       if (SqAtakd (PieceList[opponent][0], computer))
  168.     {
  169.       UnmakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst);
  170. #if defined CHESSTOOL
  171.       printz (CP[15]);
  172. #else
  173. #ifdef NONDSP
  174. /* Illegal move in check */
  175.       printz (CP[77]);
  176.       printz ("\n");
  177. #else
  178. /* Illegal move in check */
  179.       WarnMessage (CP[77]);
  180. #endif
  181. #endif /* CHESSTOOL */
  182.       return (false);
  183.     }
  184.       else
  185.     {
  186.       if (iop == 1)
  187.         return (true);
  188.       UpdateDisplay (xnode.f, xnode.t, 0, (short) xnode.flags);
  189.       if ((board[xnode.t] == pawn)
  190.           || (xnode.flags & capture)
  191.           || (xnode.flags & cstlmask))
  192.         {
  193.           Game50 = GameCnt;
  194.           ZeroRPT ();
  195.         }
  196.       GameList[GameCnt].depth = GameList[GameCnt].score = 0;
  197.       GameList[GameCnt].nodes = 0;
  198.       ElapsedTime (1);
  199.       GameList[GameCnt].time = et;
  200.       if (TCflag)
  201.         {
  202.           TimeControl.clock[opponent] -= et;
  203.           --TimeControl.moves[opponent];
  204.         }
  205.       *mv = (xnode.f << 8) | xnode.t;
  206.       algbr (xnode.f, xnode.t, false);
  207.       return (true);
  208.     }
  209.     }
  210. #if defined CHESSTOOL
  211.   printz (CP[78]);
  212. #else
  213. #ifdef NONDSP
  214. /* Illegal move */
  215.   printz (CP[75], s);
  216. #ifdef DEBUG8
  217.   if (1)
  218.     {
  219.       FILE *D;
  220.       int r, c, l;
  221.       extern unsigned short int PrVar[];
  222.       D = fopen ("/tmp/DEBUG", "a+");
  223.       pnt = TrPnt[2];
  224.       fprintf (D, "resp = %d\n", ResponseTime);
  225.       fprintf (D, "iop = %d\n", iop);
  226.       fprintf (D, "matches = %d\n", cnt);
  227.       algbr (hint >> 8, hint & 0xff, (short) 0);
  228.       fprintf (D, "hint %s\n", mvstr[0]);
  229.       fprintf (D, "inout move is %s\n", s);
  230.       for (r = 1; PrVar[r]; r++)
  231.     {
  232.       algbr (PrVar[r] >> 8, PrVar[r] & 0xff, (short) 0);
  233.       fprintf (D, " %s", mvstr[0]);
  234.     }
  235.       fprintf (D, "\n");
  236.       fprintf (D, "legal move are \n");
  237.       while (pnt < TrPnt[3])
  238.     {
  239.       node = &Tree[pnt++];
  240.       algbr (node->f, node->t, (short) node->flags);
  241.       fprintf (D, "%s %s %s %s\n", mvstr[0], mvstr[1], mvstr[2], mvstr[3]);
  242.     }
  243.       fprintf (D, "\n current board is\n");
  244.       for (r = 7; r >= 0; r--)
  245.     {
  246.       for (c = 0; c <= 7; c++)
  247.         {
  248.           l = locn (r, c);
  249.           if (color[l] == neutral)
  250.         fprintf (D, " -");
  251.           else if (color[l] == white)
  252.         fprintf (D, " %c", qxx[board[l]]);
  253.           else
  254.         fprintf (D, " %c", pxx[board[l]]);
  255.         }
  256.       fprintf (D, "\n");
  257.     }
  258.       fprintf (D, "\n");
  259.       fclose (D);
  260.       abort ();
  261.     }
  262. #endif
  263. #else
  264. /* Illegal move */
  265.   WarnMessage (CP[76]);
  266. #endif
  267. #endif /* CHESSTOOL */
  268. #if !defined CHESSTOOL && !defined XBOARD
  269.   if (cnt > 1)
  270.     WarnMessage (CP[32]);
  271. #endif /* CHESSTOOL */
  272.   return (false);
  273. }
  274.  
  275. int
  276. parser (char *f, int side)
  277. {
  278.   int c1, r1, c2, r2;
  279.  
  280.   if (f[4] == 'o')
  281.     if (side == black)
  282.       return 0x3C3A;
  283.     else
  284.       return 0x0402;
  285.   else if (f[0] == 'o')
  286.     if (side == black)
  287.       return 0x3C3E;
  288.     else
  289.       return 0x0406;
  290.   else
  291.     {
  292.       c1 = f[0] - 'a';
  293.       r1 = f[1] - '1';
  294.       c2 = f[2] - 'a';
  295.       r2 = f[3] - '1';
  296.       return (locn (r1, c1) << 8) | locn (r2, c2);
  297.     }
  298.   /*NOTREACHED*/
  299. }
  300.  
  301. void
  302. GetGame (void)
  303. {
  304.   FILE *fd;
  305.   char fname[256], *p;
  306.   int c, i, j;
  307.   short sq;
  308. /* enter file name */
  309.   ShowMessage (CP[63]);
  310.   scanz ("%s", fname);
  311. /* chess.000 */
  312.   if (fname[0] == '\0')
  313.     strcpy (fname, CP[137]);
  314.   if ((fd = fopen (fname, "r")) != NULL)
  315.     {
  316.       NewGame ();
  317.       fgets (fname, 256, fd);
  318.       computer = opponent = white;
  319.       InPtr = fname;
  320.       skip ();
  321.       if (*InPtr == 'c')
  322.     computer = black;
  323.       else
  324.     opponent = black;
  325.       skip ();
  326.       skip ();
  327.       skip ();
  328.       Game50 = atoi (InPtr);
  329.       fgets (fname, 256, fd);
  330.       InPtr = &fname[14];
  331.       castld[white] = ((*InPtr == CP[214][0]) ? true : false);
  332.       skip ();
  333.       skip ();
  334.       castld[black] = ((*InPtr == CP[214][0]) ? true : false);
  335.       fgets (fname, 256, fd);
  336.       InPtr = &fname[11];
  337.       skipb ();
  338.       TCflag = atoi (InPtr);
  339.       skip ();
  340.       InPtr += 14;
  341.       skipb ();
  342.       OperatorTime = atoi (InPtr);
  343.       fgets (fname, 256, fd);
  344.       InPtr = &fname[11];
  345.       skipb ();
  346.       TimeControl.clock